סיכום מבני נתונים )שיעור( מרצה: אלכס סמורודניצקי. להערות: אמיר נווה

סיכום מבני נתונים )שיעור( מרצה: אלכס סמורודניצקי להערות: אמיר נווה amirnaveh1@mailhujiacil

/13//30/40 שיעור 4 מבני נתונים: מרצה: אלכס סמורודניצקי salex@cshujiacil שעת קבלה: יום ג' //:40-//:40 בניין רוס /04 מתרגל: ניר רוזנפלד שעת קבלה: יום ד' בשעה //:40-//:44 ברוס / חדר 00 כתובת מייל של הקורס: dast@cshujiacil אתר הקורס: http://wwwcshujiacil/~dast צריך להגיש את כל התרגילים חוץ מ- 0 התרגילים מהווים 40% מהציון הסופי יהיה בוחן אמצע שיהווה מגן %/0 / קורסי אלגוריתמים: מבני נתונים )שנה א'(: אלגוריתמים "פשוטים" + מבני נתונים וניתוח שלהם אלגוריתמים )שנה ב'(: אלגוריתמים תיאוריה של אלגוריתמים, היררכיה של קושי של חישוביות )שנה ג'(: יותר מופשט אלגוריתמים ועל המחלקות P,NP

אלגוריתם: סדרת פעולות לביצוע משימה נתונה קלט אלגוריתם פלט מבנה נתונים: צורת אחזקת מידע המאפשרת גישה 3 עיבוד נוחים של המידע לדוגמא: מערך: הוספת מידע אלגוריתם מבני נתונים שליפת מידע אלגוריתם קבוצה דינמית עדכון מידע נושאי הקורס: אלגוריתמי מיון: אלגוריתמים שונים וניתוחם 4 מבני נתונים שונים ואלגוריתמים על מבני נהנתונים האלה 0 כמה אלגוריתמים בסיסיים: אלגוריתמים על גרפים, אלגוריתם לדחיסת מידע וכו' /

4 0 אליפות שחמט: קלט: 8 שחקני שח מטרה: אליפות: רוצים למצוא את השחקן החזק ביותר שתי אופציות: ליגה: מערך דו-מימדי )טבלה( 4 4 0 / 1 0 0 7 8 4 / / 1 0 0 7 8 0 גביע: עץ בינארי שלם 1 2 3 4 5 6 7 8 עץ: יותר יעיל )פחות משחקים( הגישה לעץ כמבנה נתונים יותר איטית ליגה: נותנת תשובה הוגנת יותר )יותר משחקים, כולם נגד כולם( בעץ התוצאה תלוייה בהגרלה הראשונית הנקודה היא: שאין תשובה חד-משמעית התשובה תלוייה במודל של העולם שיש לי

אם יש סדר בין השחקנים והשחקן החזק תמיד מנצח נעדיף גביע יעיל יורת וגם יהיה הוגן במודל מציאותי יותר נעדיף אולי ליגה )אם אין בעיות תקציב( המודל שלנו הוא למעשה מודל הסתברותי ניתוח זמן ריצה: נסמן ב-( G(n את מספר המשחקים בתחרות )בכל אחת מהשיטות: גביע או ליגה( עם n שחקנים נסמן ב-( T(n את מספר הסיבובים )מספר ימי המשחק( )כמה ימי משחק אני צריך כדי לסיים את התחרות( נניח, לשם פשטות ש-, בשיטת ליגה: ) (, בשיטת גביע: לסיכום: בשיטת הליגה: ) ( - במקרה הזה, )ריבועי במספר השחקנים( בשיטת הגביע: ) ( - במקרה הזה, )ליניארי במספר השחקנים( בשיטת הליגה: בשיטת הגביע: ולכן, כפי שחזינו מראש, שיטת הגביע היא יעילה הרבה יותר

בעיות מיון: הקלט: מערך של מספרים ממשיים: ] [ ] [ ] [ המשימה: להחזיר מערך ממויין: ] [ ] [ ] [ פעולות שניתן לעשות: גישה לתאי המערך )קריאה וכתיבה(, השוואה בין שני מספרים איך עושים את זה? אלגוריתם מיון בועות Sort( :)Bubble PSEUDOCODE: For i=1 to n-1 // Assuming array cells are indexed For j=1 to n-i DO IF A[j]>A[j+1] then SWAP A[j] and A[j+1] בדיקת נכונות האלגוריתם האם מחזיר מערך ממויין? ניתוח העלויות זמן ריצה )חישוב מספר הפעולות( מימוש טענה: האלגוריתם מחזיר מערך ממויין הוכחה: נוכיח באינדוקציה על את הטענה הבאה: לאחר צעדים בלולאה החיצונית )שתלוייה במשתנה ) המערך מכיל ב- התאים הימניים שלו את המספרים הגדולים ב- ממויינים בסדר עולה לאחר האיטרציה ה- : 1 2 3 n-i+1 n-1 בסיס האינדוקציה:, צ"ל שאחרי האיטרציה הראשונה של הלולאה הפנימית בתא ] [ עומד המספר הגדול ביותר k-1 k * * N נניח כי המספר הגדול ביותר עמד בהתחלה במקום אזי הלולאה הפנימית החל מ- תזיז אותו עד המקום האחרון )המקום ה- (

מעבר האינדוקציה, נניח את נכונות הטענה עבור ונוכיח עבור לפי הנחת האינדוקציה, אחרי הגדולים במערך הממויינים לפי הסדר: צעדים )בלולאה החיצונית(, ב- התאים האחרונים עומדים המספרים 1 2 3 n-i n-i+1 n-1 n ממויינים הלולאה הפנימית מריצה את המשתנה מ- 4 עד, ובאותו אופן כמו בניתוח עבור מביאה את המספר הגדול ביותר בין המספרים שנשארו: ] [ ] [ למקום הימני ביותר שהוא יכול ולכן, עכשיו קיבלנו ב- להגיע אליו זאת אומרת, למקום ] [ את המספרים הגדולים ב- התאים הימניים של המערך לכן, האינדוקציה עובדת, ובפרט טענת האינדוקציה נכונה עבור עבור זה מתקיים כי ב-( ( המקומות הימניים עומדים המספרים הגדולים ב-, [ ] [ ] [ ] ממויינים לפי הסדר ולכן, המערך ממויין, זאת אומרת: והאלגוריתם מסיים בהצלחה ניתוח זמן הריצה: נסמן ב-( ( את זמן הריצה של האלגוריתם על מערך בגודל האלגוריתם מבצע / סוגים של פעולות: השוואה, החלפה, קידום משתה מחיר הפעולות הוא תלוי מימוש נניח לצורך הניתוח, כי כל פעולה מחירה 4 [ ] אמרנו שמחירי הפעולות הינם תלויי מימוש נעשה חישוב במימוש אולי טיפה יותר "מציאותי", נניח כי קידום משתנה לא עולה כלום, השוואה עולה 4 והחלפה עולה /

30/40//443 יעור 0 ש- אלגוריתמי מיון: [ של מספרים ממשיים: ] מיון בועות: הקלט: מערך בגודל ] [ ] [ הפלט: מערך ממויין: ] [ For i=1 to n For j=1 to n-i If A[j]>A[j+1] SWAP A[j] and A[j+1] מיון בועות: הוכחנו נכונות )האלגוריתם אכן ממיין מערך( עשינו ניתוח זמן ריצה: 4 פעולות השוואה, החלפה וקידום משתנה כולן מחירן 4 0 השוואה עלתה 4, החלפה עלתה / וקידום משתנה / o קיבלנו זמן ריצה מעט שונה: o באפשרות הראשונה o באפשרות השנייה סימון אסימפטוטי: נתונות 0 פונקציות )זמן ריצה( נאמר כי: 4 )כאשר :) אם קיים וקבוע, כך שלכל מתקיים ) ( 0 )כאשר :) ) ) ( )ז"א ) ( אם קיים וקבוע, כך שלכל מתקיים: ) ( 3 )כאשר :) אם ) ( וגם ז"א קיים וקבוע, כך שלכל מתקיים: ) (

דוגמא: נראה כי ) (, אך לא מתקיים ) ( הוכחה: נראה כי לכל מתקיים ) ( 4 אמנם עבור מתקיים: )בכך שהוכחנו שההפרש אי-שלילי הוכחנו שאכן ) ( 0 נראה כי לא מתקיים )) ( ( ז"א לא קיים וקבוע, כך שלכל מתקיים ) ( נניח בשלילה כי קיימים ו- כאלה זאת אומרת, לכל מתקיים הצבנו את ו-, וזה נבחר מאוד גדול, כך ש: וגם אז מתקיים בסתירה לכך שבחרנו היה קל למצוא סתירה כי ידוע שפונקציה ריבועית עולה מהר יותר מליניארית, ולכן בחרנו מס' ממש גדול טענה: הפונקציה ו- מקיימות ) ( הוכחה: אמנם נראה כי לכל מתקיים ) ( 4 אמנם: הראינו ש- תמיד יותר גדולה מ- מתקיים ) ( ) ( נראה כי לכל איך יודעים למצוא את הגבול? אפשר לבחור /4 ולא 0, אבל מחפשים ומחשבים עד שמוצאים אמנם עבור : 0 דוגמא:, קל לראות ש-( ( ו-( ( עולה ריבועית ו- ליניארית, אבי היא מוכפלת במספרים ממש גבוהים

אסימפטוטית, כשבוחרים גדול, גרוע יותר מ- )כי היא עולה יותר מהר, אז זה "יקר"( * מיון בועות בצורה רקורסיבית: * הגדול ביותר * * הגדול ביותר באיטרציה הבאה הבעיה תיקטן ב- 4, והבעיה תהיה בגודל 1-n BubbleSort [ ] If n=1 RETURN (1) ELSE BUBBLE ( [ ] BubbleSort [ ] האלגוריתם קורא לעצמו זוהי לא לולאה אינסופית, כי הגודל של המערך קטן כל פעם ב- 4 )ובסוף יגיע ל- 4, שהוא תנאי העצירה( BUBBLE [ ] For j=1 to k-1 If [ ] [ ] SWAP [ ] and [ ] כל Bubble מביא את הערך הגדול ביותר לתא הימני ביותר, ואז שוב קוראים ל- Bubble על מערך קטן ב- 4 ניתוח האלגוריתם: נכונות כן )כי זה כמו האלגוריתם הקודם( זמן ריצה: נסמן ) ( את זמן הריצה של BubbleSort על קלט בגודל נסמן ) ( את זמן הריצה של BUBBLE על קלט בגודל משוואה רקורסיבית לזמן ריצה: ) ( )צורה אסימפטוטית( קריאה לעצמו של פלט יותר קטן המחיר של )הוא בודק שגודל הקלט הוא 4 ויוצא( ) (

כלומר: קבוע 4 ) ( קבוע 0 המחיר של BUBBLE הוא קבוע k הוא ליניארי S(k) זה עלות הלולאה * עושים לולאה בגודל k ועושים פעולה קבועה קבוע k טענה: ) ( הוכחה: נתון: קטן מקבוע כפול וגדול מקבוע כפול מחליפים יש לנו / קבועים: { }, נסמן: } { נראה כי ) ( וגם לכל ) ( נראה באינדוקציה על בסיס: ) ( מעבר האינדוקציה: נניח ל- ונוכיח ל- : 4 גדול יותר 0 צ"ל: ) ( )להוכיח כמו )4 אלגוריתם מיון מיזוג Sort( :)Merge אלגוריתם טוב יותר למיון מה טוב במערך ממויין? ] [ ממויין, הוא מבנה נתונים המאפשר: 4 חיפוש מהיר )בודקים האם הוא גדול או קטן מהמספר שבאמצע וכבר "מקצצים" ב- 0 את המערך לכן זה יעיל יותר( 0 הכנסת מידע בצורה יעילה MERGESORT [ ] מיון מיזוג:

IF RETURN (1) ELSE MERGESORT [ ] MERGESORT [ ] MERGE ( [ ] [ ] [ ] MERGE ( [ ] [ ] [ ]) קטן משווים בין האיברים הקטנים ביותר באמצעות pointers נניח שהתא הראשון ב- ונקדם את ה- pointer של יותר, נרשום אותו ב- את כולם נמלא ב- קטן מהמספר שב- עד שנמצא ש- נשווה ל- את המספרים שב-, וכך שגדול ממה שיש ב- pointer של עד שנמצא את, וכך נמלא את עכשיו נקדם את הלאה 4 0 / זה ליניארי, כי המערכים ממויינים ואין צורך "לחזור אחורה" ברגע שקידמנו את ה- pointer אין צורך להחזיר אותו אחורה המחיר הוא ) (

483//30/40 שיעור / MERGESORT( [ ]) If n=1 RETURN ELSE MERGESORT( [ ]) אלגוריתמי מיון מיון מיזוג SortMerge n k נדרוש סיבוכיות MERGESORT( [ ]) MERGE( [ ], [ ], [ ]) MERGE ( [ ] [ ] [ ]) A_POINTER=1, B_POINTER=1, C_POINTER=1 WHILE(A_POINTER<k+m+1) WHILE(B[B_POINTER]<C[C_POINTER] OR C_POINTER>m AND B_POINTER<k+1) A[A_POINTER]=B[B_POINTER] A_POINTER++ B_POINTER++ WHILE(C [C_POINTER]<B[B_POINTER] OR B_POINTER>k AND C_POINTER<m+1) A[A_POINTER]=C[C_POINTER] A_POINTER++ B_POINTER++ )אנחנו מניחים כי כל הערכים שונים במידה ויש ערכים שווים, נהפוך את תנאי השוויון לשוויון חלש( ניתוח האלגוריתם: נכונות כן { זמן ריצה:

עץ הרקורסיה: n k c n T(n) n k c n c n T(2) T(2) T(2) T(2) n c טענה: ) ( { ( הוכחה: נניח נראה כי הוכחת הטענה באינדוקציה על נראה קודם כי, בסיס:, : מעבר: נניח ל-, ונוכיח ל- את החצי השני אנחנו לא נבצע בכתה )זה נעשה בדיוק באותו אופן( Divide and ( ראינו דוגמא של מוין מיזוג מקרה פרטי של רעיון אלגוריתמי נפוץ: )Conquer דוגמא חשובה אלגוריתמים דינמיים )בקורס באלגוריתמים( הפרד ומשול

, בגודל בעיה כללית: נתונה בעיה בגודל האלגוריתם מחלק אותה ל- נניח כי עלות ההרכבה של הפתרונות החלקיים לפתרון המלא היא ) ( מהו זמן הריצה של האלגוריתם? {, משוואה רקורסיבית: )מיון מיזוג זה מקרה פרטי עם :) נסתכל שוב על עץ הרקורסיה ( c n k T(n) a c ( n b ) k a c ( n b ) k a r c ( n k b r ) T(b) T(b) T(b) T(b) ( ) ( )

003//30/40 - שיעור 1 שיטת האיטרציה: עבור Bubblesort נדע כי: כך פעמים, עד ש: עבור Mergesort נדע כי:, וכן כי ) ( לכן: משמע: ) ) ( ( בעיה )בגודל (: מחלקים אותה ל- בעיות מאותו סוג כל אחת בגודל: העלות של האיחוד היא ) ( משפט האב: בהינתן נוסחת נסיגה מהצורה: אם אז ) ( 4 אם אז )) ( ( 0 ( / אם אז ) ) (,, טענה: ) (, אם נוכיח 4 נוכיח באינדוקציה על בסיס:

נדע שזה נכון כי נניח את נכונות הטענה עבור כל, ונוכיח עבור, כלומר, צ"ל: מהנחת האינדוקציה נדע כי: נכפיל ונחלק ב- את הגורם השמאלי: 0 ברור : ( ) אם נוכיח / ננסה להוכיח נרצה להוכיח כי לכל נוכיח באינדוקציה על בסיס: : ולכן, הבסיס מתקיים ננסה להוכיח כי: מהגדרת ( ) ( ) ( ) ( ) כנדרש

חסמים על מיונים: עוד תוצאה של אלגוריתם מיון פרמוטציה טענה: כל אלגוריתם מיון חייב לבצע לפחות פעולות נניח בשלילה כי קיים אלגוריתם שממיין נכון קלט בגודל במקסימום אם הוא עובד נכון, אז הוא עובד נכון על מערך בגודל כך ש- ] [ פעולות מכך שנדע כי הוא עובד נכון, נדע כי קיים אינדקס כך ש- לא קורא את המערך ב-[ [ בה"כ נניח כי ניקח, כך ש-[ [ ] [, פעולת מכיוון ש- לא נגיש לתא ] [ על המערך זהה לפעולה של על המערך הפלט ש- מחזיר על שניהם זהה, ולכן הפלט של על לא נכון אלגוריתם מיון מבוסס השוואות: אלגוריתם שמחליט על סידור האיברים רק על סמך ההשוואה כל מיון מבוסס השוואות מבצע (( ( ( פעולות

403/130/40 שיעור 0 חסמים תחתונים לאלגוריתמי מיון משפט: כל אלגוריתם הממיין מערך נתון בגודל של מספרים, חייב לקחת לפחות פעולות )זמן ( הריצה הוא לפחות הנחה גישה לתא מסויים במערך עולה לפחות 4 דרישה האלגוריתם חייב להחזיר מערך ממויין נכון על כל קלט הוכחת המשפט: פעולות לצורך המיון ז"א, על פי ההנחה נניח בשלילה, כ האלגוריתם מבצע לכל היותר שהנחנו, האלגוריתם לא ניגש לתא מסויים במערך )לא רואה את ערך המספר העומד בתא הזה נסמן ( תא זה ב- נתבונן בשני הקלטים הבאים לאלגוריתם: הגדרנו את ואת כך שיהיו שונים רק במקום ה- זאת אומרת, האלגוריתם רואה שני קלטים זהים על ו-, ולכן הוא חייב להחזיר 0 פלטים זהים )חוץ מהתא ה- המקורי(, אך זאת אומרת שהוא בהכרח יטעה על אחד הקלטים, כי הפלטים הנכונים שונים בכל המקומות: ההוכחה הזאת "טריוויאלית", כי היא מוכיח שמחיר האלגוריתם הוא לפחות כגודל הקלט חסם תחתון על זמן ריצה של אלגוריתם מיון מבוסס השוואות ראינו רק אלגוריתמים מהסוג הזה: Bubblesort Mergesort ( ) Quicksort ( ) פעולות ( משפט: כל אלגוריתם מיון מבוסס השוואות דורש לפחות (( ( הנחה: האלגוריתם לא רואה את המספרים העומדים במערך בכל שלב האלגוריתם יכול לקבל את תוצאת ההשוואה בין 0 מספרים מתוך המספרים במערך 4 7 3 4 3 7 דוגמא: מיון בועות על מערך בגודל /: 3 4 7

לדוגמא, עבור מערך נעלם: זהו עץ השוואות של אלגוריתם מיון בועות על קלט בגודל / מסקנה: ריצות של כל אלגוריתם מיון המבוסס השוואות על קלט שהוא מערך של מספרים ניתן לתאר ע"י עץ השוואות: עץ בינארי עם שורש, כאשר בכל קודקוד שאינו עלה של העץ עומדת השוואה בין שני מספרים מתוך המערך, והפיצול בקודקוד הזה לשני בניו נובע משתי התוצאות האפשריות של ההשוואה זמן הריצה של האלגוריתם על הקלט הגרוע ביותר AnalysisWorse Case הוא אורך המסלול הארוך ביותר בין השורש לבין אחד מהעלים של העץ כל התוצאות האפשריות של המיון רשומות בעלים של העץ הפלטים של אלגוריתם מיון כלשהו מתאימים לסידורים האפשריים של המספרים פלט: קלט: במילים אחרות: הפלטים האפשריים של האלגוריתם מתאימים התמורות על לכל עצמים זאת אומרת, מספר הפלטים האפשריים מספר התמורות הוכחת המשפט על חסם תחתון לאלגוריתמי מיון: יהי אלגוריתם מיון מבוסס השוואות כלשהו המקבל כקלט מערך מספרים בגודל

יהי עץ ההשוואות המתאים ל- הוא עץ בינארי עם לפחות עלים זמן הריצה של הוא אורך המסלול הארוך ביותר בין השורש של לאחד העלים שלו טענה: בעץ בינארי עם לפחות עלים, יש עלה שאורכו של המסלול אליו מהשורש הוא לפחות ( ) נשים לב כי בהינתן מה שאנחנו כבר יודעים, הטענה גוררת את המשפט הגדרה: אורך המסלול הארוך ביותר בין השורש לעלה בעץ נקרא גובה העץ למת עזר: לעץ בינארי בגובה יש לכל היותר נראה כי למת העזר גוררת את הטענה הוכחת הטענה )בהינתן הלמה(: יהי עץ עם לפחות עלים ויהי הגובה של עלים לפי הלמה: ( ) ( ) כעת נשאר לנו להוכיח את הלמה הוכחת הלמה: באינדוקציה על )גובץ העץ( בסיס האינדוקציה: מספר העלים בגובה אחד ש לנו שני עצים בינאריים: 4 מעבר האינדוקציה: נניח נכונות ל- ונוכיח נכונות ל- 0 נשים לב לכך כי העלים של העץ הגדול הם איחוד קבוצות העלים של תתי העצים שלו ולכן, לפי הנחת האינדוקציה, עבור תתי-העצים, מספר העלים בעץ הגדול הוא לכל היותר, כנדרש פרק חדש:

מבני נתונים מופשטים: הכנסת איבר קבוצה דינמית של נתונים עדכון איבר הוצאת איבר בעיה אלגוריתמית: ניהול תהליכים ע"י מערכת הפעלה לכל תהליך יש קדימות ורוצים להחליט איזה תהליך להריץ בהתבסס על קדימותו פעולות שנרצה לעשות: מציאת תהליך עם קדימות מקסימלית: ) ( עדכון קדימויות: ) ( הכנסת תהליך חדש: ) ( הוצאת תהליך: ) ( איחוד תהליכים השוואה בין תהליכים ספירת תהליכים בניית מבנה הנתונים מבני נתונים שאנחנו מכירים: מערך ממויין מחסנית LIFO )פעולות: )pop,push תור FIFO רשימה מערך ממויין לפי קדימויות:

תור קדימויות: מבנה נתונים המממש תור כאשר לתהליכים בתור יש קדימויות ורוצים להתחשב בהן 003/130/40 שיעור 0 פעולות רשימה ממויינת מערך ממויין ערימה ( ) הוצאת איבר מקסימלי ) ( ( ) עדכון קדימויות ( ) הוספת איבר חדש מחיקת איבר ( ) בניית מבנה מאוסף (( ( ( תהליכים ללא מבנה הגדרה: ערימה היא עץ בינארי כמעט שלם בעלת תכונת הערימה )ממויין בצורה מסויימת( הגדרה: עץ בינארי שלם הוא עץ בינארי שלכל קודקוד פנימי )שאינו עלה( יש 0 נמצאים באותו עומק )מרחק מהשורש( בנים וכל העלים דוגמא: הגדרה: עץ בינארי כמעט שלם הוא עץ בינארי שכל הרמות שלו מלאות פרט לאולי הרמה האחרונה שיכולה להיות חסרה כמה עלים מימין דוגמא: הגדרה: ערימת המקסימום היא עץ בינארי כמעט שלם עם ערכים בקודקודים בעל התכונה הבאה: הערך בכל קודקוד פנימי גדול יותר מערכי הבנים שלו התכונה הזו נקראת תכונת הערימה

)רשימה משורשרת ממויינת( דוגמא: נממש ערימה עם איברים ע"י מערך: ] [ בגודל באופן הבא: השורש נכנס ל-[ [ הבנים של ] [ נכנסים ל- )הבן השמאלי( ו- )הבן הימני( )הרמות בעץ( מערך ] [ הוא בעל תכונת הערימה )מממש ערימת מקסימום( אם לכל מתקיים: { [ ] [ ] [ ] [ ] כדי להבין את הקשר בין המערך לערימה שהוא מממש נוח להסתכל על מיספור בנארי של קודקודי הערימה 4 עדכון ערך: עדכון ערך )הקטנת ערך( של איבר בערימה: :DECREASE_VALUE(A,i,x) DECREASE_VALUE(A,i,x)

A[i]=x (הפעולה העיקרית בערימה) MAX_HEAPIFY(A,i) השגרה MAX_HEAPIFY מקבלת כקלט תא i במערך A האמור לממש ערימת MAXIMUM כאשר מובטח כי תכונת הערימה מתקיימת בכל תאי המערך, פרט אולי לתא מספר i השיגרה מחזירה מערך בעל תכונת הערימה בכל תאיו MAX_HEAPIFY(A,i) גודל המערך: IF EXIT IF [ ] [ ] & [ ] [ ] EXIT IF [ ] [ ] THEN SWAP(A[i],A[2i]) MAX_HEAPIFY(A,2i) ELSE IF [ ] [ ] SWAP(A[i],A[2i+1]) MAX_HEAPIFY(A,2i+1) שאלה: איך מגדילים ערך? אם אנחנו מגדילים ערך, ההפרה יכולה להיות כלפי מעלה )באבא של הערך שאנחנו רוצים להחליף( לדוגמא, אנחנו רוצים להחליף את 41 בעץ הנ"ל, עם הערך /0 אז 40 )שורש העץ( מהווה הפרה אחרי ההחלפה, כי הוא קטן מהבן שלו INCREASE_VALUE (A,i,y) A[i]=y MAX_HEAPIFY( ) פתרון לא נכון! מה קורה כשעוברים למעלה ולמטה? האלגוריתם לא טוב זמן ריצה של MAX_HEAPIFY(A,i) הוא כגובה i בעץ הערימה שהוא לכל היותר גובה העץ כולו למה: הגובה של עץ בינארי כמעט שלם עם קודקודים מקיים: הוכחה: מתקיים:

פעולות מסקנה: פעולות DECREASE_VALUE,MAX_HEAPIFY לוקחות )) ( (

023/130/40 שיעור 7 ערימה :Heap 16 14 10 8 7 9 3 1 2 4 נוציא את 40, ונכניס במקומו את האחרון במערך )1( אם מממשים במערך: 4 4 2 1 10 1 9 ואז נעשה MAX_HEAPIFY על 1 נשים לב שההעברה של 1 לקודקוד הראשי שמרה על העץ כמעט שלם EXTRACT_MAX(A) PRINT A[1] A[1] A[HeapSize(A)] HeapSize(A) MAX_HEAPIFY(A,1) כי MAX_HEAPIFY הוא לוגריתמי )הוכח בשיעור הקודם( ( זמן הריצה = גובה העץ = (( ( בניית הערימה: )כזכור הדרישה היא מקסימום ללא מבנה רוצים להפוך אותו לערימת [ ] נתון מערך ) סיבוכיות של ) ( BUILD_MAX_HEAP (A) איטרציה ובכל להתחלה, מהסוף נעבור For i=n to 1 DO MAX HEAPIFY (A,i) MAX_HEAPIFY(A,i) נתקן את המערך להיות חוקי הערה: מערך תמיד מחזיר לנו עץ בינארי כמעט שלם דוגמא: נניח וקיבלנו את המערך:

8 7 3 2 14 10 16 9 1 4 1 2 3 4 5 6 7 8 9 10 8 7 3 2 14 10 16 9 1 4 נתאם על המערך כעץ בינארי כמעט שלם מקיימים את תכונת הערימה 0 אינו מקיים את תכונת הערימה נעשה MAX_HEAPIFY על 0 ונקבל: 8 7 3 2 14 10 16 0 1 4 1 2 3 4 5 6 7 8 9 10 8 7 3 9 14 10 16 2 1 4 לא מקיים את תכונת הערימה נתקן באמצעות MAX_HEAPIFY לא מקיים את תכונת הערימה נתקן באמצעות MAX_HEAPIFY לא מקיים את תכונת הערימה נתקן באמצעות MAX_HEAPIFY הערה: MAX_HEAPIFY ממשיך ברקורסיה בכל תיקון / 7 8 המערך הסופי הוא: 40 41 4/ 2 7 8 / 0 1 4 1 2 3 4 5 6 7 8 9 10

16 14 10 9 7 8 3 2 1 4,HEAPIFY(A,i) כל תתי-העצים כי אחרי הפעולה על הוכחת נכונות האלגוריתם: נוכיח באינדוקציה יורדת יהיה כולו [ הן ערימות חוקיות ואז בסוף הריצה של האלגוריתם, העץ ], [ ] הוא עלה לכן, בצורה ריקה הוא שורש של ערימת מקסימום התא ] [ ערימת מקסימום חוקית בסיס האינדוקציה: )כלומר כל תתי-העצים האלו הם ערימות מעבר האינדוקציה: נניח נכונות הטענה עבור חוקיות( ונוכיח ל- : הוא עץ בינארי כמעט שלם, ששני תתי-העצים שלו עם שורשים ב- העץ עם שורש ב-[ [ )לפי הנחת האינדוקציה( לכן, לפי מה שאנו יודעים על הם ערימות מקסימום חוקיות מתקנת את העץ להיות ערימת מקסימום,MAX_HEAPIFY הפעולה MAX_HEAPIFY(A,i) חוקית ניתוח זמן הריצה: נסמן ב-( ( את זמן הריצה של HEAP_SORT לערימה בגודל באופן ישיר הוכחה לא נכונה )כי החסם לא הדוק(: ( ) ( - מעבר * MAX_HEAPIFY כגודל המערך כי זמן הריצה של הוא לוגריתמי ( ) משפט: זמן הריצה של בניית ערימת המקסימום בגודל הוא ) (

למה: זמן ריצה של MAX_HEAPIFY(A,i) = מס' ההחלפות שהשגרה מבצעת נסמן את תוכן מערך הקלט ב- 0 + - גובה עץ הערימה גובה שאליו מגיע האיבר בסוף תהליך בניית הערימה לפני כל החלפה משווים את השורש מול [ ( ( ) ] 0 צריך מחליפים הבנים ואם הבדיקה האחרונה השורש מול של 0 A= x x x n n ) ( (בכל הפעולות של( ( ( )נשים לב שכל איבר יורד כמה שהוא יכול, ואחר כך יכול להיות שיעלה בהכרח( { },0 )לדוגמא, בעץ הקודם /, יכול לעלות יכולים לעלות יכולים לעלות פעם אחת( מספר האיברים הרמה ה- מספר העליות האפשריות של כל קודקוד ברמה ה- למה: הוכחת הלמה תגרור את נכונות המשפט, כי אם הלמה נכונה, אז: הוכחת הלמה: ( ) ( ) ( : לכל מספר טבעי מתקיים: הוכחה: אמנם, ל- זה נכון מבדיקה, ולכל )

לכן, לכל לכן: טבעי מתקיים סכום טור הנדסי כנדרש

/73/030/40 שיעור 8 עצי חיפוש בינאריים Tree Binary Search איך אנחנו מכניסים איבר? אלגוריתם הכנסת איבר: INSERT(T,Z) הערות: WHILE : z מצביע z הוא מצביע ל- 2 מצביע x עובר על העץ )חיפוש( IF מצביע y מצביע על האבא של x ELSE IF ELSE IF ( ELSE זה גובה העץ, כאשר זמן הריצה של INSERT הוא ) ( החסרון של עצי חיפוש בינאריים הוא שהם לא תמיד מאוזנים, פתרון: נעבוד רק עם עצים מאוזנים )הגובה (( ( ( מספר הקודקודים(

עצי :AVL הגדרה: עץ בינארי הוא בעל תכונת AVL אם לכל קודקוד פנימי בעץ מתקיים: (( ( ( ( ) דוגמאות: טענה: הגובה של עץ AVL עם קודקודים מקיים )) ( ( ) ( )התשובה הנכונה: ) )( למה: בעץ AVL בגובה יש לפחות הלמה גוררת את הטענה אמנם, נניח את נכונות הלמה לאחר הוכחת הטענה )תוך הלמה( הוכחת הטענה )באמצעות הלמה(: הסתמכות על עץ יהי AVL קודקודים ויהי עם הגובה של לפי הלמה: ( ) הוכחת הלמה: באינדוקציה על : - בסיס: - - - מעבר האינדוקציה: נניח את נכונות הטענה עבור ונוכיח עבור סימון: נסמן מספר הקודקודים המינימלי האפשרי של עץ AVL בגובה : נראה נסתכל על עץ בינארי בגובה 4

נראה כי אמנם, אנו יודעים עכשיו איך נראה עץ AVL עם מספר 0 קודקודים מינימלי בגובה : לכן, ) ( אינדוקציה נותר לנו להוכיח את התרגיל הבא: כנדרש

עצי חיפוש בינאריים )BST( מאוזנים עצי AVL 4/3/030/40 שיעור 2 הוכחנו כי העצים האלה הם בגובה לוגריתמי במספר הקודקודים נשאר לנו להציג אלגוריתמים להכנסה ומחיקה של איבר )יעשה בתרגולים( :) אלגוריתמים על גרפים )סימון ) (? מיהם השכנים של סוג של שאילתא: בהינתן קודקוד נממש גרך בעזרת רשימת שכנויות לכל קודקוד נתאים רשימה משורשרת של שכניו: גודל הזכרון ברשימת השכנים הוא ) ( ) ) (( זמן הריצה של האלגוריתם המחזיר את השכנים של קודקוד (מספר השכנים של ( שווה ל- גודל הייצוג של הגרף בזכרון: ( ) כעת שנשאל שאילתא יותר קשה: בהינתן גרף וקודקוד יסוד )קודקוד יסוד, משמע התחלה? ל-, הדרך הקצרה ביותר מ- s מלשון )start מהי, לכל קודקוד אנחנו מחפשים אלגוריתם יעיל במיוחד שש דרגות של הפרדה Milgram '0/ 4 תופעת העולם הקטן )אם כל קודקוד רואה רק את הקודקודים הקרובים אליו תופעה זו לא 0 תתקיים, לכן, מדי פעם קודקודים מבצעים קפיצות ענק Kleinberg /2' ניתן אלגוריתם העונה על השאלה זו זהו אלגוריתם חיפוש רוחב SearchBFS Breadth First הקלט: גרף המיוצג ע"י רשימת שכנויות וקודקוד האלגוריתם בונה ומשתמש בתור

BFS (G,s) סימון: לכל קודקוד נחזיק שדה dist(v) שמסמן שדה "מרחק" מ- לקודקוד המקור בסוף הריצה של האלגוריתם ( dist(v =מרחק אמיתי בגרף מ- ל-, שיסומן ) ( ENQUEUE (Q,s) WHILE (Q 0) u DEQUEUE (Q) FOR IF ( ) ENQUEUE (Q,v) dist(v) = dist(u)+1 נבדוק את האלגוריתם באמצעות דוגמא )עם אותו הגרף ממקודם( עם הקריאה: BFS(G,1) L שאר הקודקודים B הקודקודים שיצאו מהתור התור Q { } { } { } נעדכן את המרחק של } { ל-/ { } { } { } { ל- נעדכן את המרחקים של } { } { } { } { ל- נעדכן את המרחקים של } { } { } נעדכן את המרחק של } { ל- 0 { } { } { } { } { } { } { } הגרף הסופי נראה כך:

בטבלה שמסדירה את המעקב אחרי השדות של האלגוריתם: B Q 1 2 3 4 5 6 7 1 0 1 2,6,7 0 1 1,2 6,7,3,4 0 1 2 1 1 1,2,6,7,3,4,5 0 1 2 2 0 1 1 אם היה לנו בנוסף לקודקודים האלה את הקודקוד 8, שמנותק מכולם, אז המרחק שלו היה נותר בסוף הריצה ) זמן הריצה של אלגוריתם ה- BFS הוא ( משפט: 4 ) ( ( מתקיים ) בסוף הריצה של האלגוריתם, לכל קודקוד 0 הוכחת 4: העלות בזמן ריצה שורת הקוד ENQUEUE (Q,s) u DEQUEUE (Q) ( ) FOR ENQUEUE (Q,v) dist(v) = dist(u)+1 לסיכום: איתחול: ) ( ( ) - ו- ENQUEUE DEQUEUE

מעבר על רשימת השכנים של כל הקודקודים )פעם אחת( - ( ) לכן, ביחד זה ) (, וסיימנו הוכחת 0: מספר הקודקודים שיצאו מהתור, את הטענה הבאה: אחרי האיטרציה ה- נוכיח באינדוקציה על { מתקיימים שלושת התנאים הבאים, כאשר: } ) ( א מתקיים:, ולכל הקודקודים שכבר יצאו מהתור ) ( התור בתוך לכל הקודקודים v ב )זה ודאי נכון, כי עוד לא הגענו ) ), מתקיימים לכ יתר הקודקודים ג לקודקודים האלה, ולכן המרחק שלהם הוא המרחק שאליו אתחלנו אותו, וזה אינסוף(,, } {, בסיס האינדוקציה: ) ( מתקיים באופן ריק - א ) ( ( ובאמת: ) צריך לבדוק רק עבור ב ( ) ) ( וגם ) ( מתקיים:, ז"א לכל לכל קודקוד ב- ג נותר לנו לבצע את צעד האינדוקציה ולסיים את ההוכחה נעשה זאת בשיעור הבא

0/3/030/40 שיעור 4/ :BFS אלגוריתם חיפוש רוחב מוצא מרחק מינימלי בגרף נתון ) ( מקודקוד מוצא BFS (G,S) ENQUEUE (s) WHILE (תור (Q DO U DEQUEUE (Q) FOR EACH IF ENQUEUE (v) הוכחת נכונות: משפט: בסוף הריצה, האלגוריתם מחזיר, בתוך שדה המרחק, את המרחק הנכון מ- : הוכחה: של קבוצת הקודקודים שכבר יצאו מהתור באינדוקציה על גודל, זאת אומרת ל- סימון: נסמן ב- את מצב התור אחרי איטרציות נסמן ב- את קבוצת הקודקודים שיצאו מהתור נסמן ב- את קבוצת הקודקודים הנותרים )אלו שלא נכנסו לתור( : { מתקיים עבור: } את הטענה הבאה: לכל נוכיח באינדוקציה על ) ( א ) ( ( מתקיים: ) לכל ב ) (, ) (, לכל ג הוכחה: ונוכיח עבור בסיס האינדוקציה הוכחנו בשיעור הקודם מעבר האינדוקציה נניח שהטענה נכונה עבור נרשום: { } { } { }

{ } { לא בהכרח השכנים של ממקודם } { } נכונות של )א'(: צ"ל: ) ( נסמן מתקיים לפי )א( של הנחת האינדוקציה: ) ( מתקיים כי ) ( ) ( מצד שני, לכל ולכן, מתקיים נכונות של )ב'(: צ"ל: לכל לגבי הקודקודים בתוך, הטענה עבור הקודקודים החדשים בתוך מתקיים נקבע: זה נכון לפי הנחת האינדוקציה )טענה ב'( לכן, נשאר להוכיח את לכן, צריך להוכיח כי לכל, זאת אומרת עבור מתקיים לכ ל לפי הנחת האינדוקציה מתקיים: מצד שני, לפי הנחת האינדוקציה )סעיף ג'(, מכך ש- כי אולי יש דרך אחרת יותר קצרה להגיע ל מתקיים:, כנדרש כלומר ) ( ) ( וגם כי ) ( מתקיים: נכונות של )ג'(: צ"ל: לכל ) ( וגם כי ) ( הוכחה: מתקיים ( )! לגבי אי-השוויוןף ולא שינינו אותו באיטרציה ה- היה ( ה-( לפי ) ( לפי הנחת האינדוקציה )סעיף ג'( מתקיים: ) ( זאת אומרת: ) ( : הנחת האינדוקציה )סעיף א'( על ) (, צריך לפסול את המקרה: ) (, אזי ) ( למה: אם

, הוכחה בשלילה: נניח בשלילה כי ) ( בין ל- נסתכל על הקודקוד שלפני ונוכיח כי ) ( נצייר את המסלול הקצר לא יכול להתקיים על מרחק : ( ) מתקיים: נסמן אותו ב- ל- נתבונן על הקודקוד לפני האחרון על המסלול הקצר בין ונגיע לסתירה,, נסיים את הוכחת הלמה בזה שנוכיח כי מכיוון ) ( ( מתקיים: ) לפי הנחת האינדוקציה )סעיף א'(, לכל נראים באופן לפי הנחת האינדוקציה )סעיף א'(, שדות המרחק ב- ) ( שהנחנו הבא: המרחקים האמיתיים, אבל אז מכיוון ש-, ולכן זה הוא שהמרחק שלו מ- לכן, הקודקוד היחיד בתוך, בסתירה לכך ש- היה מתקיים שכן של מהתור באחד השלבים הקודמים של, כלומר הוצאנו את אמנם? נראה כי לתור באותה האיטרציה, בסתירה לכך ש- זה היה מכניס את שכן של האלגוריתם, מכיוון ש- ( ) ) ( כי אחרת, לפי הנחת האינדוקציה )סעיף ג'(, מתקיים למה, בסתירה לכך ש-( ( אלגוריתם של דייקסטרה משקלים שונים לצלעות בגרף: (Diycstra) למציאת מרחק מינימלי בגרף מקודקוד מוצא, כאשר יש

עצים פורשים מינימליים בגרף :MST //3/030/40 שיעור 44 דוגמא: נתונה קבוצה של ערים ורוצים לסלול רשת כבישים שתחבר את כולם, במחיר מינימלי )סכום המחירים של כל הצלעות, המחיר של רשת הכבישים = סכום המחירים של כל הכבישים ברשת( מפת רכיבי הקשירות: )באדום המחיר של הכביש( - אכן כל הערים מחוברות, בעלות המינימלית זו דוגמא לאלגוריתם חמדן Algorithm(,)Greedy אבל לא טיפש )כלומר הוא בוחר את הצלעות שלו בצורה חכמה( בצורה פורמלית, נתון גרף קשור ) (, ונתונה פונקציית מחיר המטרה היא למצוא תת-גרף קשיר ) (,, כך שהמחיר של מינימלי, כאשר נגדיר מחיר של גרף להיות ) ( אבחנה: יהי תת-גרף קשיר של בעל מחיר מינימלי, אז הוא עץ )גרף קשור חסר מעגלים( הוכחה: נניח בשלילה כי מכיל מעגל ונבנה תת-גרף קשיר של בעל מחיר נמוך יותר, וכך נגיע : לסתירה נסמן את המעגל ש- מכיל, בה"כ, ו-( ( נגדיר )}) {( ( נשים לב כי ) ( נשאר להוכיח כי הוא גרף קשיר יהיו נוכיח כי קיים מסלול ביניהם בצלעות של אם מכיוון ש- שהוא גרף קשיר, קיים מסלול בצלעות של ל- מ- הצלע אינה אחת הצלעות במסלול, סיימנו, כי המסלול הזה הוא גם מסלול ב- אחרת, נניח

: בה"כ: ) ( אזי, המסלול הבא מחבר בין ב- ל- הגדרה: נקרא לתת-הגרף הקשיר של בעל מחיר מינימלי עץ פורש מינימלי של הגדרה: יהי ) ( גרף תת-קבוצה של קודקודים נקראת מרכיב קשירות של אם לכל ניתן להגיע מ- ל- מצד שני, לכל ולכל, לא ניתן להגיע בין ל- )באדום צלע שלא סוגרת מעגל, כי היא מחברת בין שני רכיבי קשירות(; בסגול צלע שסוגרת מעגל( אלגוריתם של קרוסקל )Kruskal( למציאת :MST MST (G,W) FOR to DO FIND BETWEEN 2 distinct connected components of with minimal weight { } RETURN הערה: ניתן לממש את אלגוריתם קרוסקל, שירוץ בזמן ( ), כי: משפט: האלגוריתם מחזיר עץ פורש מינימלי של הגרף הוכחה:, נוכיח באינדוקציה על יש לגרף מרכיבי קשירות 4 קבוצת הצלעות של הגרף היא תת-קבוצה של צלעות של עץ פורש מינימלי של 0

נשים לב, כי אם נוכיח את הטענה האינדוקטיבית נסיים, כי לפי הטענה, עבור, הגרף מכיל מרכיב קשירות אחד בלבד, ולכן הוא גרף קשיר מצד שני, קבוצת הצלעות של תת-קבוצה של צלעות של עץ פורש מינימלי, ולכן, בהכרח הוא עץ פורש מינימלי של היא הוכחת הטענה האינדוקטיבית: מרכיבי קשירות וקבוצת הצלעות שלו, שהיא ריקה, היא תת- יש ( לגרף ) קבוצה של צלעות של עץ פורש מינימלי מרכיבי קשירות, זאת מכיל לפי ההנחה, הגרף ונוכיח עבור מעבר: נניח נכונות עבור כאיחוד זר: אומרת ניתן לכתוב את המחברת בין 0 מרכיבי קשירות שונים בה"כ: (, האלגוריתם מוסיף צלע ) באיטרציה,, הם:, רכיבי הקשירות של הגרף נשם לב כי אחרי הוספת הצלע נשאר להוכיח כי קבוצת הצלעות בזמן היא עדיין תת-קבוצה של צלעות של עץ פורש מינימלי נסמן ב- את קבוצת הצלעות בזמן, ז"א, היא קבוצת הצלעות של ו-{ { לפי הנחת האינדוקציה, היא תת-קבוצה של צלעות של עץ פורש מינימלי: צריך להוכיח זאת עבור { } הגדרה: בגרף חתך זו חלוקה של קודקודים לשתי קבוצות הגדרה: צלע שייכת לחתך ) ( אם

הגדרה: חתך ) ( מכבד קבוצה של צלעות אם אף צלע אינה שייכת לחתך למה מרכזית: תהי תת-קבוצה של צלעות של עץ פורש מינימלי של ) (, יהי ) ( חתך לא ריק המכבד את תהי צלע השייכת לחתך ובעלת משקל מינימלי בין כל הצלעות בחתך אזי, הקבוצה } { היא תת-קבוצה של צלעות של עץ פורש מינימלי הוכחת הלמה: נסמן את יהי עץ פורש מינימלי, המכיל את הצלעות של מכיוון ש- הוא גרף קשיר, קיים בו מסלול מ- ל- )מסומן בתמונה למעלה בסגול( המסלול הזה חייב להכיל צלע השייכת לחתך אנחנו יודעים שני דברים על : כי החתך מכבד את ו-( (, וזה כי היא צלע בחתך בעלת משקל מינימלי נגדיר ( { } { }) קבוצת הצלעות של בשיעור הבא נראה כי הוא עץ פורש מינימלי, שלפי ההגדרה מכיל את } {

4/3/030/40 שיעור 40 בעיית :MST מציאת עץ פורש מינימלי בגרף קשיר במילים אחרות, נתון גרף קשיר ) ( גרף פורש וקשיר ) ( משקל, כך ש-, ולכל תת-קבוצה של צלעות, כך שהמשקל של צריך למצוא תת- מינימלי, כאשר נתונה פונקציית נגדיר: ) ( האלגוריתם הפותר את הבעיה הוא אלגוריתם חמדן, הבוחר צלעות של באופן איטרטיבי, כאשר בכל שלב האלגוריתם בוחר את הצלע הזולה ביותר שאינה סוגרת מעגל האלגוריתם של Kruskal MST (G,W) FOR to DO: RETURN FIND between distinct connected components of of minimal weight { } משפט: האלגוריתם מחזיר עץ פורש מינימלי של כדי להוכיח את המשפט, מספיק להוכיח טענה מתקיים: אינדוקטיבית: לכל 4 לגרף יש רכיבי קשירות 0 קבוצת הצלעות של היא תת-קבוצה של צלעות של עץ פורש מינימלי הגדרות: 4 חתך בגרף זו חלוקה של קודקודי הגרף לשתי קבוצות ) ( 0 צלע שייכת לחתך אם ) (, / חתך מכבד קבוצה של צלעות אם לכל, אינה שייכת לחתך למה מרכזית: תהי תת-קבוצה של צלעות של עץ פורש מינימלי יהי ) ( חתך המכבד את תהי צלע קלה בחתך אזי, } { היא תת-קבוצה של עץ פורש מינימלי

עץ פורש מינימלי המכיל את מכיל מסלול יהי ) (, תהי ) ( המחבר בין ל- : המסלול הזה מכיל צלע השייכת לחתך נגדיר: } { } {, ) ( נראה כי הוא עץ פורש מינימלי, שקבוצת הצלעות שלו מכילה את } { ובזה נסיים את הוכחת הלמה נשים לב כי, )כי שייכת לחתך והחתך מכבד את (, ולכן } { } { מכילה את } { נשים לב לכך שלגרף ({ { ( יש 0 רכיבי קשירות: אמנם, מכיוון שב- יש מסלול יחיד בין ל- והורדנו צלע במסלול זה, עכשיו לא ניתן להגיע בין ל- בצלעות הנותרות של לכן, נמצאים ברכיבי קשירות שונים של ({ { ) מצד שני, לגרף הזה איות יותר מ- 0 רכיבי קשירות, כי הוספת צלע חזרה הופכת אותו לגרף קשיר נשי םלב כי הצלע ) ( מחברת קודקודים ב- 0 רכיבי קשירות שונים של הגרף ({ { ) לכן הגרף החדש שקיבלנו: קשיר נשים לב לכך ש-( (, ולכן חייב להיות ) ( ו- ) ( הוא עץ פורש מינימלי סיום הוכחת הטענה האינדוקטיבית: נגדיר לפי הנחת האינדוקציה, ברכיבי הקשירות של : היא תת-קבוצה של צלעות של עץ פורש מינימלי נתבונן נניח בה"כ כי מחברת בין ו- נגדיר חתך באופן הבא:, החתך מכבד את, וגם היא צלע בעלת משקל מינימלי בחתך לכן, לפי הלמה המרכזית היא תת-קבוצה של צלעות של עץ פורש מינימלי { } { } אלגוריתם הקידוד של Huffman )הופמן(: נתון קובץ הכתוב באנגלית באותיות a,b,c,d,e,f המטרה: לקודד את אותיות הטקסט ע"י סדרות של ביטים )אפסים ואחדים(, כך ש: 4 נוכל לשחזר את הקובץ המקורי 0 אורך הקידוד )גודל הקובץ הבינארי של הקידוד( יהיה קטן כמה שאפשר

באלגוריתם של הופמן עוברים על הקובץ פעמיים: פעם אחת עושים,parsing ובעצם מעין סטטיסטיקה, ובפעם השנייה מקודדים, בהתאם ל"סטטיסטיקה" שנאספה בתהליך ה- parsing ובוחרים את הקידוד האופטימלי המטרה של אלגוריתם בבסיסו היא להעביר מידע בצורה יעילה קידוד פענוח תורת האינפורמציה: קולט ערוץ תקשורת משדר בקובץ יש //4 אלף אותיות: a b c d e f 10 מספר המופעים באלפים 4/ 40 40 2 0 /// אורך הקודקוד: ///,/// ביטים //4 /4/ /44 4// 4/4 / אורך הקודקוד: ///,410 ביטים 4 // /4 4/ 44 אורך הקודקוד: ///,001 ביט, והוא אופטימלי בין כל הקידודים חסרי רישא )ראו בהמשך( 0 101 100 111 1101 1100 בעיה: הבעיה בצורה פורמלית: נתון א"ב ומחפשים פונקציית קידוד: { } כל הסדרות הבינאריות באורכים שונים המאפשרת פענוח הגדרה: קידוד חסר רישא הוא פונקציית קידוד כך שלכל שתי אותיות מתקיים: ) ( אינו התחלה של הקידוד של דוגמא לקידוד חסר רישא בדוגמא הנ"ל בצבע אדום פענוח של הסדרה:, הגדרה: בהינתן פונקציית קידוד } { נגדיר עבור להיות אורך הקידוד בביטים של הגדרה: בהינתן קובץ הכתוב באותיות מ-, נגדיר ) ( להיות מספר המופעים של האות ואז, אורך הקידוד הכולל של קובץ הוא: ) ( בקובץ, כך ש-( ( בעיה: בהינתן, מצאו קידוד חסר רישא של מינימלי

קידוד הופמן: נתון קובץ את מספר הפעמים ש- הכתוב באותיות של א"ב מחפשים קידוד חסר רישא: מופיעה ב- 473/030/40 שיעור 47 { }, כאשר הקובץ קובע תדירות מופע של כל אות ) (, כך שמתקיים: ) (, כאשר ) ( מסמן הוא אורך הקידוד של גישה כללית: לתת שפה ממתמטית מתאימה לפתרון הבעיה 4 לחקור תכונות של פתרון אופטימלי 0 נתאים לכל קידוד: } { עץ בינארי a b c d e f 45 13 12 16 9 5 0 101 100 111 1101 1100 דוגמא: אבחנות: כל האותיות מתאימות לעלים של העץ הבינארי קידוד חסר רישא מצד שני, עץ שהאותיות של הא"ב עומדים בעלים שלו נותן קידוד חסר רישא מסקנה: ניתן לתרגם את הבעיה לבעיה הבאה: בהינתן קובץ, מחפשים עץ בינארי עם עלים, עם התאמה בין לעלים, כך שמשיגים מינימום: ) (, כאשר ) ( הוא העומק של העלה המתאים ל- בעץ תכונות הפתרון האופטימלי )נניח מעכשיו שכל התדירויות שונות זו מזו( יהי פתרון אופטימלי

, אזי ) (, כך ש-( ( למה 4: תהיינה ו- שתי אותיות בא"ב הוכחה: אזי, נניח בשלילה כי ) ( נגדיר קידוד חדש שבו מחליפים בין הקידוד של וזה של ( ) ( ) ( ) ( ) ( ) ( ) ז"א: ) ( בסתירה לאופטימליות של יש שני בנים )עץ בינארי כזה נקרא עץ מלא( עץ אופטימלי, אז לכל קודקוד פנימי של למה 0: יהי הוכחה: עם בן יחיד ב- נניח בשלילה כי קיים קודקוד הוא הבן של ו- הוא אבא של בעץ ו- נמצא בין הקודקודים נניח כי אורכי הקידוד של להיות הבן של מהעץ ונהפוך את ע"י כך שנמחק את נבנה עץ חדש האותיות יכולים רק לקטון )ובאמת יקטנו עבור כל העלים הצאצאים של ( למה /: תהיינה שתי אותיות ב- בעלות תדירות מינימלית אז קיים פתרון אופטימלי, כך ש- מתאימם לעלים אחים ב- הוכחה: יהי עץ אופטימלי נניח בה"כ כי ) ( לפי למה 4, נמצא ברמה התחתונה של העץ, ז"א ) ( מקסימלי לפי למה 0, ל- יש אח, שנסמנו אם סיימנו אחרת, מכיוון ש- ) ( ו-( (, נוכל להחליף בין הקידודים של ושל, ולקבל עץ אופטימלי שבו אחים הרעיון הפותר את הבעיה של קידוד אופטימלי תהיינה עם תדירות מינימלית יהי עץ אופטמלי בו אחים מתאים לקידוד של א"ב, ] { } {, ) (

(תדירויות - ( f) Huffman (A, IF RETURN IF ELSE FIND RETURN { } { } of minimal frequency = HUFFMAN RETURN פיצול של z ל -x ו -y דוגמא:

משפט: האלגוריתם מחזיר ץ קידוד אופטימלי הוכחה: סימון נחליף את הסימן ) ( ב-( ( נוכיח באינדוקציה על גודל הא"ב בסיס: האלגוריתם מחזיר קידוד אופטימלי נניח ל- ונוכיח ל- נניח בשלילה כי לא"ב ופונקציית תדירות, קיים קידוד חסר רישא, כך ש- ) ( כאשר יסמן את העץ המתקבל מאלגוריתם Huffman אחים האותיות עם התדירות המינימלית ב- שבו לפי למה /, קיים קידוד אופטימלי, ) ( : ) ( עם פונקציית תדירות { } נתבונן בקודקוד של א"ב: } { והחלפתן בא"ב ע"י מחיקה של המתקבל מ-, הניתן ע"י העץ ) ( המתקבל מהאלגוריתם של ( ע"י העץ, ונשוואה את הקודקוד הזה לקודקוד של ) המשותף ( ) מצד שני, לפי הנחת השלילה: ( Huffman לפי הנחת האינדוקציה ) נשים לב כי: מתקיים: ( ) ( ) ( ) ) כלומר ) ( קטן מעצמו, וזוהי סתירה, באותו אופן: ( ) ולכן, קיבלנו ש- הנחת האינדוקציה הנחת השלילה כנדרש

על המבחן: הבחינה תהיה באותה המתכונת של שנה שעברה חלק ראשון: 1 שאלות מתוך 0 כל שאלה /4 נקודות, כדוגמת להפעיל אלגוריתם הופמן על קלט כלשהו חלק שני: 0 שאלות מתוך / שאלות גדולות כל שאלה // נקודות כל שאלה מורכבת מ-/ סעיפים, כשמתוכם 0 סעיפים )שהם בערך /0 נקודות( זה משהו שאמורים לדעת לגמרי, סעיף ראשון זה בדר"כ הגדרות, סעיף שני זה משפט או דברים שקשורים אליו והסעיף השלישי זה משהו שאולי לא בדיוק ראינו או משהו קצת שונה למעשה, יש /0 נקודות שמראות על הבנה עמוקה יותר איזשהו טוויסט על משהו שאנחנו אמורים לדעת לפחות שאלה אחת מתוך ה-/ בחלק השני תהיה שאלה שהופיעה בתרגילים )לא כולל סעיף ג'(